home *** CD-ROM | disk | FTP | other *** search
/ MPEG Toolkit / MPEG Toolkit.iso / dos / secmpeg3 / sec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  8.4 KB  |  329 lines
  1.  
  2. /* --- C ---
  3. ************************************************************************
  4. *
  5. *    Filename    : sec.c
  6. *    Description : Security routines - Confidentiality and Integrity
  7. *                                      coding and decoding
  8. *    Part of     : SECMPEG
  9. *
  10. *    Version     : 1.0
  11. *    Language    : C
  12. *    For machine : SunOS 4.1.x, INTERACTIVE Unix 2.2.1, Linux, MS-DOS
  13. *    Compile as  : see Makefile
  14. *
  15. *    Authors     : Juergen Meyer, Frank Gadegast
  16. *    Contact     : jm@cs.tu-berlin.de, phade@cs.tu-berlin.de
  17. *
  18. ************************************************************************
  19. */
  20.  
  21. #include <stdio.h>
  22. #include "defs.h"
  23. #include "marker.h"
  24.  
  25. /* ------ PUBLIC ------ */
  26.  
  27. int                    WriteSecureMpegHeader();
  28. int                  WriteSecureMpegInfo();
  29. int                    ReadSecureMpegHeader();
  30. int                    ReadSecureMpegInfo();
  31. unsigned long       GetPictureHeader(int);
  32. int                 EncryptFrame(int,unsigned long);
  33. int                 DecryptFrame(int,unsigned long);
  34. int                 SetTableEntries(int,unsigned long);
  35.  
  36. /* ------ PRIVAT ------ */
  37.  
  38. /* ------ IMPORT ------ */
  39.  
  40. extern int          Encrypt(char *,unsigned long);   /* des.c */
  41. extern int          Decrypt(char *,unsigned long);
  42.  
  43. extern int          GetByte();                       /* stream.c */
  44. extern int          _GetnBit(int);
  45. extern void         readalign();
  46. extern BYTE         *frame_buffer;
  47. extern int          input;
  48. extern int          output;
  49. extern long         total_bytes_read;
  50. extern int          end_of_file;
  51.  
  52. extern int          c_level;                         /* main.c */
  53. extern int          i_level;
  54. extern int          c_table_entries;
  55. extern SECUREHEADER sec_header;
  56. extern SECUREINFO   sec_info;
  57. extern SECURETABLE  c_table[];
  58. extern INTEGRTABLE  i_table[];
  59. extern int          WRITE;
  60.  
  61. extern int          HorizontalSize;
  62. extern int          VerticalSize;
  63.  
  64.  
  65. int    WriteSecureMpegHeader()
  66. {
  67.     strncpy (sec_header.Info,HEADER_INFO, 8);
  68.     strncpy (sec_header.Id  ,HEADER_ID, 8);
  69.     if (c_level > -1)
  70.         Encrypt ((char *)&sec_header+8, sizeof (SECUREHEADER)-8);
  71.     if (WRITE)
  72.         return (write (output, (void *)&sec_header, sizeof(SECUREHEADER)));
  73.     else return (TRUE);
  74. }
  75.  
  76. int    WriteSecureMpegInfo()
  77. {
  78.     unsigned table_size;
  79.     short    c_size;
  80.  
  81.     c_size = sec_info.ConfidentialityDataSize;
  82.  
  83.     if (c_level > -1)
  84.         Encrypt((char *)&sec_info,(unsigned long)sizeof(SECUREINFO));
  85.     if (WRITE)
  86.         write(output,(void *)&sec_info,sizeof(SECUREINFO));
  87.     if (i_level > -1)
  88.     {
  89.         table_size = sizeof (INTEGRTABLE);
  90.         table_size += (DESBLOCK - (table_size % 8));
  91. /*
  92.         if (c_level > -1) Encrypt((char *)&i_table, table_size);
  93. */
  94.         if (WRITE)
  95.             write (output, (void *)&i_table, table_size);
  96.     }
  97.     if(c_size > 0)
  98.     {
  99.         table_size = sizeof(SECURETABLE) * c_size;
  100.         table_size += (DESBLOCK - (table_size % 8));
  101.         Encrypt((char *)&c_table, (unsigned long)table_size);
  102.         if (WRITE)
  103.             write(output,(void *)&c_table,table_size);
  104.     }
  105.     return(TRUE);
  106. }
  107.  
  108. int    ReadSecureMpegHeader()
  109. {
  110.     if (read (input, (void *)&sec_header, sizeof(SECUREHEADER)) !=
  111.         sizeof (SECUREHEADER)) return(ERROR_READ);
  112.     if (strncmp (sec_header.Info,HEADER_INFO,8)) return (ERROR_NO_SECMPEG);
  113.     if (strncmp (sec_header.Id, HEADER_ID, 8))
  114.     {
  115.         Decrypt ((char *)&sec_header+8, sizeof (SECUREHEADER)-8);
  116.         if (strncmp (sec_header.Id, HEADER_ID, 8)) return (ERROR_NOT_FGJM);
  117.     }
  118.     i_level = (int) sec_header.IntegrityInfo;
  119.     c_level = (int) sec_header.ConfidentialityInfo;
  120.     return(TRUE);
  121. }
  122.  
  123. int    ReadSecureMpegInfo()
  124. {
  125.     unsigned table_size;
  126.  
  127.     if (read (input, (void *)&sec_info, sizeof(SECUREINFO)) !=
  128.         sizeof (SECUREINFO)) return (ERROR_READ);
  129.     if (c_level > -1)
  130.         Decrypt ((char *)&sec_info, (unsigned long)sizeof(SECUREINFO));
  131.     if (!sec_info.NextHeader) end_of_file = TRUE;
  132.     if (i_level > -1)
  133.     {
  134.        table_size = sizeof(INTEGRTABLE);
  135.        table_size += (DESBLOCK - (table_size % 8));
  136.        if(read(input,(void *)&i_table,table_size) != table_size)
  137.           return(ERROR_READ);
  138. /*
  139.        if (c_level > -1) Decrypt ((char *)&i_table, table_size);
  140. */
  141.     }
  142.     if (sec_info.ConfidentialityDataSize > 0)
  143.     {
  144.        table_size = sizeof (SECURETABLE) * sec_info.ConfidentialityDataSize;
  145.        table_size += (DESBLOCK - (table_size % 8));
  146.        if (read (input,(void *) &c_table,table_size) != table_size)
  147.           return (ERROR_READ);
  148.        Decrypt ((char *)&c_table, (unsigned long)table_size);
  149.     }
  150.     return(TRUE);
  151. }
  152.  
  153. unsigned long      GetPictureHeader(int fill_table)
  154. {
  155.   
  156.   int            index = 2;
  157.    int            mbsc[3];
  158.   int            trailor_val;
  159.   int            sliceheader = 0;
  160.   unsigned long  start;
  161.   unsigned short len;
  162.  
  163. #ifdef DEBUG
  164.   fprintf(stderr,"%s \n","GetHeader");
  165. #endif
  166.  
  167.   c_table_entries = 0;
  168.   readalign();
  169.   start = total_bytes_read;             
  170.   mbsc[0] = GetByte();
  171.   mbsc[1] = GetByte();
  172.   do
  173.   {
  174.      mbsc[index++] = GetByte();
  175.      if((mbsc[0] + mbsc[1] + mbsc[2]) == 1) 
  176.      {
  177.      trailor_val = GetByte();
  178. #ifdef TEST_DEBUG
  179.      fprintf(stderr,
  180.         " found header at : %lu  headertype %d \t",
  181.         total_bytes_read,trailor_val);
  182. #endif
  183.  
  184.      switch(trailor_val)
  185.      {
  186.            case  PSC : return(total_bytes_read - start);
  187.  
  188.            case VSEC : end_of_file = TRUE;
  189.                return(total_bytes_read - start);
  190.  
  191.            case VSSC : HorizontalSize = _GetnBit(12);      /* eigendlich VS Header  */
  192.                VerticalSize   = _GetnBit(12);      /* mehr Information wird */
  193.                readalign();                        /* aber nicht ben÷tigt   */
  194.  
  195.                break;
  196.            case UDSC :
  197.            case EXSC :
  198.  
  199.            case GOPSC: if(fill_table)
  200.                   c_table[c_table_entries++].Offset = (unsigned short)(total_bytes_read - start);                     
  201.                break;
  202.  
  203.            default   : if(fill_table)
  204.                   c_table[c_table_entries++].Offset = (unsigned short)(total_bytes_read - start);
  205.                break;
  206.      }
  207.  
  208.      mbsc[0] = mbsc[1] = mbsc[2] = 0xff;
  209.  
  210.      }
  211.      index = index % 3;
  212.  
  213.   }
  214.   while(!end_of_file);
  215. #ifdef DEBUG
  216.   fprintf(stderr,"%s \n","no more Header found (End of File)");
  217. #endif
  218.   return(0L);
  219. }
  220.  
  221.  
  222. int      EncryptFrame(int table_size,unsigned long frame_len)
  223. {
  224.     int    i;
  225.  
  226.     if(table_size)
  227.        for(i = 0 ; i < table_size; i++)
  228.           Encrypt((char *)frame_buffer+c_table[i].Offset,c_table[i].Len);
  229.     else
  230.           Encrypt((char *)frame_buffer,frame_len);
  231.     return(TRUE);
  232. }
  233.  
  234.  
  235. int     DecryptFrame(int table_size, unsigned long frame_len)
  236. {
  237.         int     i;
  238.  
  239.         if(table_size)
  240.            for(i = 0 ; i < table_size; i++)
  241.               Decrypt((char *)frame_buffer+c_table[i].Offset,c_table[i].Len);
  242.         else
  243.               Decrypt((char *)frame_buffer,frame_len);
  244.         return(TRUE);
  245. }
  246.  
  247.  
  248. int    SetTableEntries(int nbytes,unsigned long frame_len)
  249. {
  250.     int           index = 0;
  251.         int            i;
  252.         unsigned short len;
  253.         
  254.         c_table[0].Offset = 0;
  255.         c_table[0].Len    = (unsigned short)nbytes;
  256.         c_table[1].Len    = 0;
  257.         for(i = 1;i < c_table_entries; i++)
  258.     {   
  259.             c_table[i].Offset -= 4;
  260.             if(c_table[i].Offset > (c_table[index].Len + c_table[index].Offset))
  261.             {
  262.                index++;
  263.                c_table[index].Offset = c_table[i].Offset ;
  264.                c_table[index].Len    = (unsigned short)nbytes;
  265.             }
  266.             else
  267.                c_table[index].Len   += (unsigned short)nbytes;
  268.            
  269.     }
  270.         
  271.         if((c_table[index].Offset + c_table[index].Len) > (unsigned short)frame_len)     
  272.     {
  273.             /* last header is not a SliceHeader */
  274.            
  275.             len = (unsigned short)frame_len - c_table[index].Offset;
  276.             len += 7;
  277.             len >>= 3;
  278.             len <<= 3;
  279.             if((c_table[index-1].Offset + c_table[index-1].Len + len) > (unsigned short)frame_len)
  280.         {
  281.                index--;
  282.                c_table[index].Len   += len;
  283.         }
  284.             else
  285.                c_table[index].Len = len;
  286.             c_table[index].Offset = (unsigned short)frame_len - c_table[index].Len;  
  287.                        
  288.     }
  289.       
  290.         index++;
  291.  
  292.         return(index);
  293. }
  294.  
  295. int CryptStream (code)
  296. int code;
  297. {
  298.     long len;
  299.  
  300.     do
  301.     {
  302.         len = read (input, (void *)frame_buffer, (unsigned)FRAME_BUFFERSIZE);
  303.         if (len > -1)
  304.         {
  305.             if (code == M_CENCRYPT) Encrypt ((char *)frame_buffer, len);
  306.             else Decrypt ((char *)frame_buffer, len);
  307.             write (output, (void *)frame_buffer, (unsigned)len);
  308.         }
  309.     } while (len == FRAME_BUFFERSIZE);
  310.     if (len < 0) return (ERROR_READ);
  311.     else return (ERROR_NONE);
  312. }
  313.  
  314. long mvalue = 0;
  315.  
  316. int CrcStream ()
  317. {
  318.     long len;
  319.  
  320.     do
  321.     {
  322.         len = read (input, (void *)frame_buffer, (unsigned)FRAME_BUFFERSIZE);
  323.         if (len > -1) mvalue += crc32buf ((char *)frame_buffer, len);
  324.     } while (len == FRAME_BUFFERSIZE);
  325.     if (len < 0) return (ERROR_READ);
  326.     else return (ERROR_NONE);
  327. }
  328.  
  329.